/**
 * 通用数据服务类
 * 
 * 提供数据的获取、处理和存储功能，采用单例模式设计。
 * 当前版本使用模拟数据，在实际应用中应替换为真实的API调用。
 * 支持用户、产品、文章等多种数据类型的分页查询、搜索和排序。
 * 
 * @fileoverview 数据服务类，提供数据获取、处理和存储功能
 * @author HarmonyOS开发团队
 * @version 1.0.0
 */

import { UserData, ProductData, ArticleData, ApiResponse, PageRequest, PageResponse, UserStatus, ErrorInfo } from './DataModels';
import { ErrorUtils, AppError, ErrorType, ErrorLevel } from './ErrorHandler';
import hilog from '@ohos.hilog';
import { cacheManager } from './CacheManager';

// 通用数据服务类
// 提供数据的获取、处理和存储功能
export class DataService {
  private static readonly TAG = 'DataService';
  
  /**
   * 模拟用户数据
   * 
   * 用于演示和测试的用户数据数组。
   * 在实际应用中，这些数据应该从服务器获取。
   */
  private static mockUsers: UserData[] = [
    {
      id: 'user1',
      title: '张三',
      description: '前端开发工程师，专注于移动应用开发',
      name: '张三',
      email: 'zhangsan@example.com',
      phone: '13800138001',
      avatar: 'https://example.com/avatar1.jpg',
      status: UserStatus.ACTIVE,
      timestamp: '2023-11-01T10:00:00Z'
    },
    {
      id: 'user2',
      title: '李四',
      description: '后端开发工程师，擅长系统架构设计',
      name: '李四',
      email: 'lisi@example.com',
      phone: '13800138002',
      avatar: 'https://example.com/avatar2.jpg',
      status: UserStatus.ACTIVE,
      timestamp: '2023-11-02T14:30:00Z'
    },
    {
      id: 'user3',
      title: '王五',
      description: '产品经理，负责需求分析和产品规划',
      name: '王五',
      email: 'wangwu@example.com',
      phone: '13800138003',
      avatar: 'https://example.com/avatar3.jpg',
      status: UserStatus.INACTIVE,
      timestamp: '2023-10-15T09:15:00Z'
    },
    {
      id: 'user4',
      title: '赵六',
      description: 'UI/UX设计师，专注于用户体验设计',
      name: '赵六',
      email: 'zhaoliu@example.com',
      phone: '13800138004',
      avatar: 'https://example.com/avatar4.jpg',
      status: UserStatus.SUSPENDED,
      timestamp: '2023-09-20T16:45:00Z'
    }
  ];
  
  /**
   * 模拟产品数据
   * 
   * 用于演示和测试的产品数据数组。
   * 在实际应用中，这些数据应该从服务器获取。
   */
  private static mockProducts: ProductData[] = [
    {
      id: 'product1',
      title: '智能手机',
      description: '最新款智能手机，搭载高性能处理器，支持5G网络',
      price: 3999,
      category: '电子产品',
      stock: 100,
      rating: 4.5,
      tags: ['5G', '高性能', '拍照'],
      imageUrl: 'https://example.com/product1.jpg',
      timestamp: '2023-11-01T10:00:00Z'
    },
    {
      id: 'product2',
      title: '笔记本电脑',
      description: '轻薄便携的笔记本电脑，适合办公和学习',
      price: 5999,
      category: '电子产品',
      stock: 50,
      rating: 4.8,
      tags: ['轻薄', '高性能', '长续航'],
      imageUrl: 'https://example.com/product2.jpg',
      timestamp: '2023-11-02T14:30:00Z'
    },
    {
      id: 'product3',
      title: '无线耳机',
      description: '高品质无线耳机，支持主动降噪功能',
      price: 899,
      category: '音频设备',
      stock: 200,
      rating: 4.2,
      tags: ['无线', '降噪', '长续航'],
      imageUrl: 'https://example.com/product3.jpg',
      timestamp: '2023-10-15T09:15:00Z'
    },
    {
      id: 'product4',
      title: '智能手表',
      description: '多功能智能手表，支持健康监测和运动追踪',
      price: 1299,
      category: '可穿戴设备',
      stock: 80,
      rating: 4.0,
      tags: ['健康监测', '运动', '防水'],
      imageUrl: 'https://example.com/product4.jpg',
      timestamp: '2023-09-20T16:45:00Z'
    }
  ];
  
  /**
   * 模拟文章数据
   * 
   * 用于演示和测试的文章数据数组。
   * 在实际应用中，这些数据应该从服务器获取。
   */
  private static mockArticles: ArticleData[] = [
    {
      id: 'article1',
      title: '鸿蒙应用开发入门指南',
      description: '介绍鸿蒙应用开发的基础知识和开发环境搭建',
      author: '张三',
      content: '鸿蒙操作系统是华为自主研发的分布式操作系统，支持多种设备类型...',
      publishDate: '2023-11-01',
      readTime: 10,
      category: '技术教程',
      views: 1500,
      likes: 120,
      timestamp: '2023-11-01T10:00:00Z'
    },
    {
      id: 'article2',
      title: '前端框架对比分析',
      description: '对比分析当前流行的前端框架，包括React、Vue和Angular',
      author: '李四',
      content: '前端框架是现代Web开发的重要工具，不同的框架有不同的特点和适用场景...',
      publishDate: '2023-10-28',
      readTime: 15,
      category: '技术分析',
      views: 2000,
      likes: 180,
      timestamp: '2023-10-28T14:30:00Z'
    },
    {
      id: 'article3',
      title: '移动应用性能优化技巧',
      description: '分享移动应用开发中的性能优化经验和技巧',
      author: '王五',
      content: '移动应用的性能优化是提升用户体验的关键，本文将介绍几种常见的优化方法...',
      publishDate: '2023-10-20',
      readTime: 12,
      category: '性能优化',
      views: 1200,
      likes: 95,
      timestamp: '2023-10-20T09:15:00Z'
    },
    {
      id: 'article4',
      title: '人工智能在移动应用中的应用',
      description: '探讨人工智能技术在移动应用中的应用场景和实现方法',
      author: '赵六',
      content: '人工智能技术正在改变移动应用的开发方式，从智能推荐到语音识别...',
      publishDate: '2023-10-15',
      readTime: 18,
      category: '人工智能',
      views: 1800,
      likes: 150,
      timestamp: '2023-10-15T16:45:00Z'
    }
  ];
  
  /**
   * 获取用户列表（带分页和缓存）
   * @param pageRequest 分页请求参数
   * @returns 分页响应数据
   */
  public static async getUserList(pageRequest?: PageRequest): Promise<ApiResponse<PageResponse<UserData>>> {
    try {
      hilog.info(0x0000, this.TAG, '获取用户列表');
      
      // 验证分页参数
      if (pageRequest) {
        if (pageRequest.page && pageRequest.page < 1) {
          const error = ErrorUtils.createValidationError('页码必须大于0', { field: 'page', value: pageRequest.page });
          const errorInfo: ErrorInfo = {
            code: error.code,
            message: error.message,
            field: 'page'
          };
          
          return {
            code: 400,
            message: '请求参数错误',
            data: {} as PageResponse<UserData>,
            timestamp: new Date().toISOString(),
            error: errorInfo
          };
        }
        
        if (pageRequest.pageSize && (pageRequest.pageSize < 1 || pageRequest.pageSize > 100)) {
          const error = ErrorUtils.createValidationError('每页大小必须在1-100之间', { field: 'pageSize', value: pageRequest.pageSize });
          const errorInfo: ErrorInfo = {
            code: error.code,
            message: error.message,
            field: 'pageSize'
          };
          
          return {
            code: 400,
            message: '请求参数错误',
            data: {} as PageResponse<UserData>,
            timestamp: new Date().toISOString(),
            error: errorInfo
          };
        }
      }
      
      // 生成缓存键
      const cacheKey = `userList_${JSON.stringify(pageRequest)}`;
      
      // 尝试从缓存获取数据
      const cachedData = cacheManager.get<ApiResponse<PageResponse<UserData>>>(cacheKey);
      if (cachedData) {
        hilog.info(0x0000, this.TAG, '%{public}s', `从缓存获取用户列表: ${cacheKey}`);
        return cachedData;
      }
      
      // 模拟网络请求延迟
      await new Promise(resolve => setTimeout(resolve, 500));
      
      // 模拟网络错误（10%概率）
      if (Math.random() < 0.1) {
        const error = ErrorUtils.createNetworkError('网络连接失败');
        ErrorUtils.handleError(error);
        
        const errorInfo: ErrorInfo = {
          code: error.code,
          message: error.message
        };
        
        return {
          code: 500,
          message: '网络错误',
          data: {} as PageResponse<UserData>,
          timestamp: new Date().toISOString(),
          error: errorInfo
        };
      }
      
      // 处理分页
      const page = pageRequest?.page || 1;
      const pageSize = pageRequest?.pageSize || 10;
      const startIndex = (page - 1) * pageSize;
      const endIndex = startIndex + pageSize;
      
      // 处理搜索
      let filteredUsers = this.mockUsers;
      if (pageRequest?.keyword) {
        const keyword = pageRequest.keyword.toLowerCase();
        filteredUsers = this.mockUsers.filter(user => 
          user.name.toLowerCase().includes(keyword) || 
          user.email.toLowerCase().includes(keyword) ||
          user.description.toLowerCase().includes(keyword)
        );
      }
      
      // 处理排序
      if (pageRequest?.sortBy) {
        try {
          filteredUsers.sort((a, b) => {
            const aValue = a[pageRequest.sortBy as keyof UserData];
            const bValue = b[pageRequest.sortBy as keyof UserData];
            
            if (aValue === undefined || bValue === undefined) return 0;
            
            if (pageRequest.sortOrder === 'desc') {
              return aValue > bValue ? -1 : aValue < bValue ? 1 : 0;
            } else {
              return aValue < bValue ? -1 : aValue > bValue ? 1 : 0;
            }
          });
        } catch (e) {
          const error = ErrorUtils.createValidationError('无效的排序字段', { field: 'sortBy', value: pageRequest.sortBy });
          ErrorUtils.handleError(error);
          
          // 继续使用默认排序
        }
      }
      
      // 获取当前页数据
      const list = filteredUsers.slice(startIndex, endIndex);
      
      // 构建响应
      const response: ApiResponse<PageResponse<UserData>> = {
        code: 200,
        message: '获取成功',
        data: {
          list,
          total: filteredUsers.length,
          page,
          pageSize,
          totalPages: Math.ceil(filteredUsers.length / pageSize)
        },
        timestamp: new Date().toISOString()
      };
      
      // 将响应存入缓存（3分钟）
      cacheManager.set(cacheKey, response, 3 * 60 * 1000);
      
      return response;
    } catch (error) {
      // 处理未知错误
      const appError = ErrorUtils.fromException(
        error as Error,
        ErrorType.UNKNOWN,
        ErrorLevel.ERROR,
        { method: 'getUserList', params: pageRequest }
      );
      
      const handlingResult = ErrorUtils.handleError(appError);
      
      const errorInfo: ErrorInfo = {
        code: appError.code,
        message: handlingResult.message || appError.message,
        details: appError.details
      };
      
      return {
        code: 500,
        message: '服务器内部错误',
        data: {} as PageResponse<UserData>,
        timestamp: new Date().toISOString(),
        error: errorInfo
      };
    }
  }
  
  /**
   * 获取用户详情（带缓存）
   * @param id 用户ID
   * @returns 用户详情
   */
  public static async getUserDetail(id: string): Promise<ApiResponse<UserData | null>> {
    try {
      hilog.info(0x0000, this.TAG, `获取用户详情: ${id}`);
      
      // 验证参数
      if (!id) {
        const error = ErrorUtils.createValidationError('用户ID不能为空', { field: 'id', value: id });
        const errorInfo: ErrorInfo = {
          code: error.code,
          message: error.message,
          field: 'id'
        };
        
        return {
          code: 400,
          message: '请求参数错误',
          data: null,
          timestamp: new Date().toISOString(),
          error: errorInfo
        };
      }
      
      // 生成缓存键
      const cacheKey = `userDetail_${id}`;
      
      // 尝试从缓存获取数据
      const cachedData = cacheManager.get<ApiResponse<UserData | null>>(cacheKey);
      if (cachedData) {
        hilog.info(0x0000, this.TAG, '%{public}s', `从缓存获取用户详情: ${cacheKey}`);
        return cachedData;
      }
      
      // 模拟网络请求延迟
      await new Promise(resolve => setTimeout(resolve, 300));
      
      // 模拟网络错误（5%概率）
      if (Math.random() < 0.05) {
        const error = ErrorUtils.createNetworkError('网络连接失败');
        ErrorUtils.handleError(error);
        
        const errorInfo: ErrorInfo = {
          code: error.code,
          message: error.message
        };
        
        return {
          code: 500,
          message: '网络错误',
          data: null,
          timestamp: new Date().toISOString(),
          error: errorInfo
        };
      }
      
      const user = this.mockUsers.find(u => u.id === id) || null;
      
      const response: ApiResponse<UserData | null> = {
        code: user ? 200 : 404,
        message: user ? '获取成功' : '用户不存在',
        data: user,
        timestamp: new Date().toISOString()
      };
      
      // 将响应存入缓存（5分钟）
      cacheManager.set(cacheKey, response, 5 * 60 * 1000);
      
      return response;
    } catch (error) {
      // 处理未知错误
      const appError = ErrorUtils.fromException(
        error as Error,
        ErrorType.UNKNOWN,
        ErrorLevel.ERROR,
        { method: 'getUserDetail', params: { id } }
      );
      
      const handlingResult = ErrorUtils.handleError(appError);
      
      const errorInfo: ErrorInfo = {
        code: appError.code,
        message: handlingResult.message || appError.message,
        details: appError.details
      };
      
      return {
        code: 500,
        message: '服务器内部错误',
        data: null,
        timestamp: new Date().toISOString(),
        error: errorInfo
      };
    }
  }
  
  /**
   * 获取产品列表（带分页和缓存）
   * @param pageRequest 分页请求参数
   * @returns 分页响应数据
   */
  public static async getProductList(pageRequest?: PageRequest): Promise<ApiResponse<PageResponse<ProductData>>> {
    hilog.info(0x0000, this.TAG, '获取产品列表');
    
    // 生成缓存键
    const cacheKey = `productList_${JSON.stringify(pageRequest)}`;
    
    // 尝试从缓存获取数据
    const cachedData = cacheManager.get<ApiResponse<PageResponse<ProductData>>>(cacheKey);
    if (cachedData) {
      hilog.info(0x0000, this.TAG, '%{public}s', `从缓存获取产品列表: ${cacheKey}`);
      return cachedData;
    }
    
    // 模拟网络请求延迟
    await new Promise(resolve => setTimeout(resolve, 500));
    
    // 处理分页
    const page = pageRequest?.page || 1;
    const pageSize = pageRequest?.pageSize || 10;
    const startIndex = (page - 1) * pageSize;
    const endIndex = startIndex + pageSize;
    
    // 处理搜索
    let filteredProducts = this.mockProducts;
    if (pageRequest?.keyword) {
      const keyword = pageRequest.keyword.toLowerCase();
      filteredProducts = this.mockProducts.filter(product => 
        product.title.toLowerCase().includes(keyword) || 
        product.category.toLowerCase().includes(keyword) ||
        product.description.toLowerCase().includes(keyword)
      );
    }
    
    // 处理排序
    if (pageRequest?.sortBy) {
      filteredProducts.sort((a, b) => {
        const aValue = a[pageRequest.sortBy as keyof ProductData];
        const bValue = b[pageRequest.sortBy as keyof ProductData];
        
        if (aValue === undefined || bValue === undefined) return 0;
        
        if (pageRequest.sortOrder === 'desc') {
          return aValue > bValue ? -1 : aValue < bValue ? 1 : 0;
        } else {
          return aValue < bValue ? -1 : aValue > bValue ? 1 : 0;
        }
      });
    }
    
    // 获取当前页数据
    const list = filteredProducts.slice(startIndex, endIndex);
    
    // 构建响应
    const response: ApiResponse<PageResponse<ProductData>> = {
      code: 200,
      message: '获取成功',
      data: {
        list,
        total: filteredProducts.length,
        page,
        pageSize,
        totalPages: Math.ceil(filteredProducts.length / pageSize)
      },
      timestamp: new Date().toISOString()
    };
    
    // 将响应存入缓存（3分钟）
    cacheManager.set(cacheKey, response, 3 * 60 * 1000);
    
    return response;
  }
  
  /**
   * 获取产品详情
   * @param id 产品ID
   * @returns 产品详情
   */
  public static async getProductDetail(id: string): Promise<ApiResponse<ProductData | null>> {
    hilog.info(0x0000, this.TAG, `获取产品详情: ${id}`);
    
    // 模拟网络请求延迟
    await new Promise(resolve => setTimeout(resolve, 300));
    
    const product = this.mockProducts.find(p => p.id === id) || null;
    
    const response: ApiResponse<ProductData | null> = {
      code: product ? 200 : 404,
      message: product ? '获取成功' : '产品不存在',
      data: product,
      timestamp: new Date().toISOString()
    };
    
    return response;
  }
  
  /**
   * 获取文章列表（带分页和缓存）
   * @param pageRequest 分页请求参数
   * @returns 分页响应数据
   */
  public static async getArticleList(pageRequest?: PageRequest): Promise<ApiResponse<PageResponse<ArticleData>>> {
    hilog.info(0x0000, this.TAG, '获取文章列表');
    
    // 生成缓存键
    const cacheKey = `articleList_${JSON.stringify(pageRequest)}`;
    
    // 尝试从缓存获取数据
    const cachedData = cacheManager.get<ApiResponse<PageResponse<ArticleData>>>(cacheKey);
    if (cachedData) {
      hilog.info(0x0000, this.TAG, '%{public}s', `从缓存获取文章列表: ${cacheKey}`);
      return cachedData;
    }
    
    // 模拟网络请求延迟
    await new Promise(resolve => setTimeout(resolve, 500));
    
    // 处理分页
    const page = pageRequest?.page || 1;
    const pageSize = pageRequest?.pageSize || 10;
    const startIndex = (page - 1) * pageSize;
    const endIndex = startIndex + pageSize;
    
    // 处理搜索
    let filteredArticles = this.mockArticles;
    if (pageRequest?.keyword) {
      const keyword = pageRequest.keyword.toLowerCase();
      filteredArticles = this.mockArticles.filter(article => 
        article.title.toLowerCase().includes(keyword) || 
        article.author.toLowerCase().includes(keyword) ||
        article.category.toLowerCase().includes(keyword)
      );
    }
    
    // 处理排序
    if (pageRequest?.sortBy) {
      filteredArticles.sort((a, b) => {
        const aValue = a[pageRequest.sortBy as keyof ArticleData];
        const bValue = b[pageRequest.sortBy as keyof ArticleData];
        
        if (aValue === undefined || bValue === undefined) return 0;
        
        if (pageRequest.sortOrder === 'desc') {
          return aValue > bValue ? -1 : aValue < bValue ? 1 : 0;
        } else {
          return aValue < bValue ? -1 : aValue > bValue ? 1 : 0;
        }
      });
    }
    
    // 获取当前页数据
    const list = filteredArticles.slice(startIndex, endIndex);
    
    // 构建响应
    const response: ApiResponse<PageResponse<ArticleData>> = {
      code: 200,
      message: '获取成功',
      data: {
        list,
        total: filteredArticles.length,
        page,
        pageSize,
        totalPages: Math.ceil(filteredArticles.length / pageSize)
      },
      timestamp: new Date().toISOString()
    };
    
    // 将响应存入缓存（3分钟）
    cacheManager.set(cacheKey, response, 3 * 60 * 1000);
    
    return response;
  }
  
  /**
   * 获取文章详情
   * @param id 文章ID
   * @returns 文章详情
   */
  public static async getArticleDetail(id: string): Promise<ApiResponse<ArticleData | null>> {
    hilog.info(0x0000, this.TAG, `获取文章详情: ${id}`);
    
    // 模拟网络请求延迟
    await new Promise(resolve => setTimeout(resolve, 300));
    
    const article = this.mockArticles.find(a => a.id === id) || null;
    
    const response: ApiResponse<ArticleData | null> = {
      code: article ? 200 : 404,
      message: article ? '获取成功' : '文章不存在',
      data: article,
      timestamp: new Date().toISOString()
    };
    
    return response;
  }
  
  /**
   * 保存数据到本地存储
   * 
   * 将数据保存到设备的本地存储中，以便离线访问或缓存。
   * 注意：当前实现为模拟版本，实际应用中应使用鸿蒙的数据存储API。
   * 
   * @param key 存储键，用于唯一标识数据
   * @param data 要存储的数据，可以是任意类型
   * @returns Promise<boolean> 保存是否成功
   */
  public static async saveToLocalStorage(key: string, data: any): Promise<boolean> {
    try {
      hilog.info(0x0000, this.TAG, `保存数据到本地存储: ${key}`);
      
      // 验证参数
      if (!key || key.trim() === '') {
        const error = ErrorUtils.createValidationError('存储键不能为空', { field: 'key', value: key });
        ErrorUtils.handleError(error);
        return false;
      }
      
      if (data === undefined) {
        const error = ErrorUtils.createValidationError('存储数据不能为undefined', { field: 'data', value: data });
        ErrorUtils.handleError(error);
        return false;
      }
      
      // 在实际应用中，这里应该使用鸿蒙的数据存储API
      // 例如：@ohos.data.preferences 或 @ohos.data.rdb
      await new Promise(resolve => setTimeout(resolve, 200));
      
      // 模拟存储失败（5%概率）
      if (Math.random() < 0.05) {
        const error = ErrorUtils.createSystemError('本地存储写入失败');
        ErrorUtils.handleError(error);
        return false;
      }
      
      return true;
    } catch (error) {
      // 处理未知错误
      const appError = ErrorUtils.fromException(
        error as Error,
        ErrorType.SYSTEM,
        ErrorLevel.ERROR,
        { method: 'saveToLocalStorage', params: { key } }
      );
      
      ErrorUtils.handleError(appError);
      return false;
    }
  }

  /**
   * 从本地存储获取数据
   * 
   * 从设备的本地存储中检索之前保存的数据。
   * 注意：当前实现为模拟版本，实际应用中应使用鸿蒙的数据存储API。
   * 
   * @param key 存储键，用于唯一标识数据
   * @returns Promise<any> 存储的数据，如果不存在或出错则返回null
   */
  public static async getFromLocalStorage(key: string): Promise<any> {
    try {
      hilog.info(0x0000, this.TAG, `从本地存储获取数据: ${key}`);
      
      // 验证参数
      if (!key || key.trim() === '') {
        const error = ErrorUtils.createValidationError('存储键不能为空', { field: 'key', value: key });
        ErrorUtils.handleError(error);
        return null;
      }
      
      // 在实际应用中，这里应该使用鸿蒙的数据存储API
      // 例如：@ohos.data.preferences 或 @ohos.data.rdb
      await new Promise(resolve => setTimeout(resolve, 200));
      
      // 模拟读取失败（5%概率）
      if (Math.random() < 0.05) {
        const error = ErrorUtils.createSystemError('本地存储读取失败');
        ErrorUtils.handleError(error);
        return null;
      }
      
      // 模拟数据不存在（20%概率）
      if (Math.random() < 0.2) {
        hilog.info(0x0000, this.TAG, `本地存储中不存在数据: ${key}`);
        return null;
      }
      
      // 模拟返回数据
      return { mockData: `模拟数据_${key}`, timestamp: new Date().toISOString() };
    } catch (error) {
      // 处理未知错误
      const appError = ErrorUtils.fromException(
        error as Error,
        ErrorType.SYSTEM,
        ErrorLevel.ERROR,
        { method: 'getFromLocalStorage', params: { key } }
      );
      
      ErrorUtils.handleError(appError);
      return null;
    }
  }
}